/*!
 * JQVMap: jQuery Vector Map Library
 * @author JQVMap <me@peterschmalfeldt.com>
 * @version 1.5.1
 * @link http://jqvmap.com
 * @license https://github.com/manifestinteractive/jqvmap/blob/master/LICENSE
 * @builddate 2016/06/02
 */

var VectorCanvas = function (width, height, params) {
    this.mode = window.SVGAngle ? 'svg' : 'vml';
    this.params = params;

    if (this.mode === 'svg') {
        this.createSvgNode = function (nodeName) {
            return document.createElementNS(this.svgns, nodeName);
        };
    } else {
        try {
            if (!document.namespaces.rvml) {
                document.namespaces.add('rvml', 'urn:schemas-microsoft-com:vml');
            }
            this.createVmlNode = function (tagName) {
                return document.createElement('<rvml:' + tagName + ' class="rvml">');
            };
        } catch (e) {
            this.createVmlNode = function (tagName) {
                return document.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
            };
        }

        document.createStyleSheet().addRule('.rvml', 'behavior:url(#default#VML)');
    }

    if (this.mode === 'svg') {
        this.canvas = this.createSvgNode('svg');
    } else {
        this.canvas = this.createVmlNode('group');
        this.canvas.style.position = 'absolute';
    }

    this.setSize(width, height);
};

VectorCanvas.prototype = {
    svgns: 'http://www.w3.org/2000/svg',
    mode: 'svg',
    width: 0,
    height: 0,
    canvas: null
};

var ColorScale = function (colors, normalizeFunction, minValue, maxValue) {
    if (colors) {
        this.setColors(colors);
    }
    if (normalizeFunction) {
        this.setNormalizeFunction(normalizeFunction);
    }
    if (minValue) {
        this.setMin(minValue);
    }
    if (minValue) {
        this.setMax(maxValue);
    }
};

ColorScale.prototype = {
    colors: []
};

var JQVMap = function (params) {
    params = params || {};
    var map = this;
    var mapData = JQVMap.maps[params.map];
    var mapPins;

    if (!mapData) {
        throw new Error('Invalid "' + params.map + '" map parameter. Please make sure you have loaded this map file in your HTML.');
    }

    this.selectedRegions = [];
    this.multiSelectRegion = params.multiSelectRegion;

    this.container = params.container;

    this.defaultWidth = mapData.width;
    this.defaultHeight = mapData.height;

    this.color = params.color;
    this.selectedColor = params.selectedColor;
    this.hoverColor = params.hoverColor;
    this.hoverColors = params.hoverColors;
    this.hoverOpacity = params.hoverOpacity;
    this.setBackgroundColor(params.backgroundColor);

    this.width = params.container.width();
    this.height = params.container.height();

    this.resize();

    jQuery(window).resize(function () {
        var newWidth = params.container.width();
        var newHeight = params.container.height();

        if (newWidth && newHeight) {
            map.width = newWidth;
            map.height = newHeight;
            map.resize();
            map.canvas.setSize(map.width, map.height);
            map.applyTransform();

            var resizeEvent = jQuery.Event('resize.jqvmap');
            jQuery(params.container).trigger(resizeEvent, [newWidth, newHeight]);

            if (mapPins) {
                jQuery('.jqvmap-pin').remove();
                map.pinHandlers = false;
                map.placePins(mapPins.pins, mapPins.mode);
            }
        }
    });

    this.canvas = new VectorCanvas(this.width, this.height, params);
    params.container.append(this.canvas.canvas);

    this.makeDraggable();

    this.rootGroup = this.canvas.createGroup(true);

    this.index = JQVMap.mapIndex;
    this.label = jQuery('<div/>').addClass('jqvmap-label').appendTo(jQuery('body')).hide();

    if (params.enableZoom) {
        jQuery('<div/>').addClass('jqvmap-zoomin').text('+').appendTo(params.container);
        jQuery('<div/>').addClass('jqvmap-zoomout').html('&#x2212;').appendTo(params.container);
    }

    map.countries = [];

    for (var key in mapData.paths) {
        var path = this.canvas.createPath({
            path: mapData.paths[key].path
        });

        path.setFill(this.color);
        path.id = map.getCountryId(key);
        map.countries[key] = path;

        if (this.canvas.mode === 'svg') {
            path.setAttribute('class', 'jqvmap-region');
        } else {
            jQuery(path).addClass('jqvmap-region');
        }

        jQuery(this.rootGroup).append(path);
    }

    jQuery(params.container).delegate(this.canvas.mode === 'svg' ? 'path' : 'shape', 'mouseover mouseout', function (e) {
        var containerPath = e.target,
            code = e.target.id.split('_').pop(),
            labelShowEvent = jQuery.Event('labelShow.jqvmap'),
            regionMouseOverEvent = jQuery.Event('regionMouseOver.jqvmap');

        code = code.toLowerCase();

        if (e.type === 'mouseover') {
            jQuery(params.container).trigger(regionMouseOverEvent, [code, mapData.paths[code].name]);
            if (!regionMouseOverEvent.isDefaultPrevented()) {
                map.highlight(code, containerPath);
            }
            if (params.showTooltip) {
                map.label.text(mapData.paths[code].name);
                jQuery(params.container).trigger(labelShowEvent, [map.label, code]);

                if (!labelShowEvent.isDefaultPrevented()) {
                    map.label.show();
                    map.labelWidth = map.label.width();
                    map.labelHeight = map.label.height();
                }
            }
        } else {
            map.unhighlight(code, containerPath);

            map.label.hide();
            jQuery(params.container).trigger('regionMouseOut.jqvmap', [code, mapData.paths[code].name]);
        }
    });

    jQuery(params.container).delegate(this.canvas.mode === 'svg' ? 'path' : 'shape', 'click', function (regionClickEvent) {

        var targetPath = regionClickEvent.target;
        var code = regionClickEvent.target.id.split('_').pop();
        var mapClickEvent = jQuery.Event('regionClick.jqvmap');

        code = code.toLowerCase();

        jQuery(params.container).trigger(mapClickEvent, [code, mapData.paths[code].name]);

        if (!params.multiSelectRegion && !mapClickEvent.isDefaultPrevented()) {
            for (var keyPath in mapData.paths) {
                map.countries[keyPath].currentFillColor = map.countries[keyPath].getOriginalFill();
                map.countries[keyPath].setFill(map.countries[keyPath].getOriginalFill());
            }
        }

        if (!mapClickEvent.isDefaultPrevented()) {
            if (map.isSelected(code)) {
                map.deselect(code, targetPath);
            } else {
                map.select(code, targetPath);
            }
        }
    });

    if (params.showTooltip) {
        params.container.mousemove(function (e) {
            if (map.label.is(':visible')) {
                var left = e.pageX - 15 - map.labelWidth;
                var top = e.pageY - 15 - map.labelHeight;

                if (left < 0) {
                    left = e.pageX + 15;
                }
                if (top < 0) {
                    top = e.pageY + 15;
                }

                map.label.css({
                    left: left,
                    top: top
                });
            }
        });
    }

    this.setColors(params.colors);

    this.canvas.canvas.appendChild(this.rootGroup);

    this.applyTransform();

    this.colorScale = new ColorScale(params.scaleColors, params.normalizeFunction, params.valueMin, params.valueMax);

    if (params.values) {
        this.values = params.values;
        this.setValues(params.values);
    }

    if (params.selectedRegions) {
        if (params.selectedRegions instanceof Array) {
            for (var k in params.selectedRegions) {
                this.select(params.selectedRegions[k].toLowerCase());
            }
        } else {
            this.select(params.selectedRegions.toLowerCase());
        }
    }

    this.bindZoomButtons();

    if (params.pins) {
        mapPins = {
            pins: params.pins,
            mode: params.pinMode
        };

        this.pinHandlers = false;
        this.placePins(params.pins, params.pinMode);
    }

    if (params.showLabels) {
        this.pinHandlers = false;

        var pins = {};
        for (key in map.countries) {
            if (typeof map.countries[key] !== 'function') {
                if (!params.pins || !params.pins[key]) {
                    pins[key] = key.toUpperCase();
                }
            }
        }

        mapPins = {
            pins: pins,
            mode: 'content'
        };

        this.placePins(pins, 'content');
    }

    JQVMap.mapIndex++;
};

JQVMap.prototype = {
    transX: 0,
    transY: 0,
    scale: 1,
    baseTransX: 0,
    baseTransY: 0,
    baseScale: 1,
    width: 0,
    height: 0,
    countries: {},
    countriesColors: {},
    countriesData: {},
    zoomStep: 1.4,
    zoomMaxStep: 4,
    zoomCurStep: 1
};

JQVMap.xlink = 'http://www.w3.org/1999/xlink';
JQVMap.mapIndex = 1;
JQVMap.maps = {};

(function () {

    var apiParams = {
        colors: 1,
        values: 1,
        backgroundColor: 1,
        scaleColors: 1,
        normalizeFunction: 1,
        enableZoom: 1,
        showTooltip: 1,
        borderColor: 1,
        borderWidth: 1,
        borderOpacity: 1,
        selectedRegions: 1,
        multiSelectRegion: 1
    };

    var apiEvents = {
        onLabelShow: 'labelShow',
        onLoad: 'load',
        onRegionOver: 'regionMouseOver',
        onRegionOut: 'regionMouseOut',
        onRegionClick: 'regionClick',
        onRegionSelect: 'regionSelect',
        onRegionDeselect: 'regionDeselect',
        onResize: 'resize'
    };

    jQuery.fn.vectorMap = function (options) {

        var defaultParams = {
            map: 'world_en',
            backgroundColor: '#a5bfdd',
            color: '#f4f3f0',
            hoverColor: '#c9dfaf',
            hoverColors: {},
            selectedColor: '#c9dfaf',
            scaleColors: ['#b6d6ff', '#005ace'],
            normalizeFunction: 'linear',
            enableZoom: true,
            showTooltip: true,
            borderColor: '#818181',
            borderWidth: 1,
            borderOpacity: 0.25,
            selectedRegions: null,
            multiSelectRegion: false
        }, map = this.data('mapObject');

        if (options === 'addMap') {
            JQVMap.maps[arguments[1]] = arguments[2];
        } else if (options === 'set' && apiParams[arguments[1]]) {
            map['set' + arguments[1].charAt(0).toUpperCase() + arguments[1].substr(1)].apply(map, Array.prototype.slice.call(arguments, 2));
        } else if (typeof options === 'string' &&
            typeof map[options] === 'function') {
            return map[options].apply(map, Array.prototype.slice.call(arguments, 1));
        } else {
            jQuery.extend(defaultParams, options);
            defaultParams.container = this;
            this.css({position: 'relative', overflow: 'hidden'});

            map = new JQVMap(defaultParams);

            this.data('mapObject', map);

            this.unbind('.jqvmap');

            for (var e in apiEvents) {
                if (defaultParams[e]) {
                    this.bind(apiEvents[e] + '.jqvmap', defaultParams[e]);
                }
            }

            var loadEvent = jQuery.Event('load.jqvmap');
            jQuery(defaultParams.container).trigger(loadEvent, map);

            return map;
        }
    };

})(jQuery);

ColorScale.arrayToRgb = function (ar) {
    var rgb = '#';
    var d;
    for (var i = 0; i < ar.length; i++) {
        d = ar[i].toString(16);
        rgb += d.length === 1 ? '0' + d : d;
    }
    return rgb;
};

ColorScale.prototype.getColor = function (value) {
    if (typeof this.normalize === 'function') {
        value = this.normalize(value);
    }

    var lengthes = [];
    var fullLength = 0;
    var l;

    for (var i = 0; i < this.colors.length - 1; i++) {
        l = this.vectorLength(this.vectorSubtract(this.colors[i + 1], this.colors[i]));
        lengthes.push(l);
        fullLength += l;
    }

    var c = (this.maxValue - this.minValue) / fullLength;

    for (i = 0; i < lengthes.length; i++) {
        lengthes[i] *= c;
    }

    i = 0;
    value -= this.minValue;

    while (value - lengthes[i] >= 0) {
        value -= lengthes[i];
        i++;
    }

    var color;
    if (i === this.colors.length - 1) {
        color = this.vectorToNum(this.colors[i]).toString(16);
    } else {
        color = (this.vectorToNum(this.vectorAdd(this.colors[i], this.vectorMult(this.vectorSubtract(this.colors[i + 1], this.colors[i]), (value) / (lengthes[i]))))).toString(16);
    }

    while (color.length < 6) {
        color = '0' + color;
    }
    return '#' + color;
};

ColorScale.rgbToArray = function (rgb) {
    rgb = rgb.substr(1);
    return [parseInt(rgb.substr(0, 2), 16), parseInt(rgb.substr(2, 2), 16), parseInt(rgb.substr(4, 2), 16)];
};

ColorScale.prototype.setColors = function (colors) {
    for (var i = 0; i < colors.length; i++) {
        colors[i] = ColorScale.rgbToArray(colors[i]);
    }
    this.colors = colors;
};

ColorScale.prototype.setMax = function (max) {
    this.clearMaxValue = max;
    if (typeof this.normalize === 'function') {
        this.maxValue = this.normalize(max);
    } else {
        this.maxValue = max;
    }
};

ColorScale.prototype.setMin = function (min) {
    this.clearMinValue = min;

    if (typeof this.normalize === 'function') {
        this.minValue = this.normalize(min);
    } else {
        this.minValue = min;
    }
};

ColorScale.prototype.setNormalizeFunction = function (f) {
    if (f === 'polynomial') {
        this.normalize = function (value) {
            return Math.pow(value, 0.2);
        };
    } else if (f === 'linear') {
        delete this.normalize;
    } else {
        this.normalize = f;
    }
    this.setMin(this.clearMinValue);
    this.setMax(this.clearMaxValue);
};

ColorScale.prototype.vectorAdd = function (vector1, vector2) {
    var vector = [];
    for (var i = 0; i < vector1.length; i++) {
        vector[i] = vector1[i] + vector2[i];
    }
    return vector;
};

ColorScale.prototype.vectorLength = function (vector) {
    var result = 0;
    for (var i = 0; i < vector.length; i++) {
        result += vector[i] * vector[i];
    }
    return Math.sqrt(result);
};

ColorScale.prototype.vectorMult = function (vector, num) {
    var result = [];
    for (var i = 0; i < vector.length; i++) {
        result[i] = vector[i] * num;
    }
    return result;
};

ColorScale.prototype.vectorSubtract = function (vector1, vector2) {
    var vector = [];
    for (var i = 0; i < vector1.length; i++) {
        vector[i] = vector1[i] - vector2[i];
    }
    return vector;
};

ColorScale.prototype.vectorToNum = function (vector) {
    var num = 0;
    for (var i = 0; i < vector.length; i++) {
        num += Math.round(vector[i]) * Math.pow(256, vector.length - i - 1);
    }
    return num;
};

JQVMap.prototype.applyTransform = function () {
    var maxTransX, maxTransY, minTransX, minTransY;
    if (this.defaultWidth * this.scale <= this.width) {
        maxTransX = (this.width - this.defaultWidth * this.scale) / (2 * this.scale);
        minTransX = (this.width - this.defaultWidth * this.scale) / (2 * this.scale);
    } else {
        maxTransX = 0;
        minTransX = (this.width - this.defaultWidth * this.scale) / this.scale;
    }

    if (this.defaultHeight * this.scale <= this.height) {
        maxTransY = (this.height - this.defaultHeight * this.scale) / (2 * this.scale);
        minTransY = (this.height - this.defaultHeight * this.scale) / (2 * this.scale);
    } else {
        maxTransY = 0;
        minTransY = (this.height - this.defaultHeight * this.scale) / this.scale;
    }

    if (this.transY > maxTransY) {
        this.transY = maxTransY;
    } else if (this.transY < minTransY) {
        this.transY = minTransY;
    }
    if (this.transX > maxTransX) {
        this.transX = maxTransX;
    } else if (this.transX < minTransX) {
        this.transX = minTransX;
    }

    this.canvas.applyTransformParams(this.scale, this.transX, this.transY);
};

JQVMap.prototype.bindZoomButtons = function () {
    var map = this;
    this.container.find('.jqvmap-zoomin').click(function () {
        map.zoomIn();
    });
    this.container.find('.jqvmap-zoomout').click(function () {
        map.zoomOut();
    });
};

JQVMap.prototype.deselect = function (cc, path) {
    cc = cc.toLowerCase();
    path = path || jQuery('#' + this.getCountryId(cc))[0];

    if (this.isSelected(cc)) {
        this.selectedRegions.splice(this.selectIndex(cc), 1);

        jQuery(this.container).trigger('regionDeselect.jqvmap', [cc]);
        path.currentFillColor = path.getOriginalFill();
        path.setFill(path.getOriginalFill());
    } else {
        for (var key in this.countries) {
            this.selectedRegions.splice(this.selectedRegions.indexOf(key), 1);
            this.countries[key].currentFillColor = this.color;
            this.countries[key].setFill(this.color);
        }
    }
};

JQVMap.prototype.getCountryId = function (cc) {
    return 'jqvmap' + this.index + '_' + cc;
};

JQVMap.prototype.getPin = function (cc) {
    var pinObj = jQuery('#' + this.getPinId(cc));
    return pinObj.html();
};

JQVMap.prototype.getPinId = function (cc) {
    return this.getCountryId(cc) + '_pin';
};

JQVMap.prototype.getPins = function () {
    var pins = this.container.find('.jqvmap-pin');
    var ret = {};
    jQuery.each(pins, function (index, pinObj) {
        pinObj = jQuery(pinObj);
        var cc = pinObj.attr('for').toLowerCase();
        var pinContent = pinObj.html();
        ret[cc] = pinContent;
    });
    return JSON.stringify(ret);
};

JQVMap.prototype.highlight = function (cc, path) {
    path = path || jQuery('#' + this.getCountryId(cc))[0];
    if (this.hoverOpacity) {
        path.setOpacity(this.hoverOpacity);
    } else if (this.hoverColors && (cc in this.hoverColors)) {
        path.currentFillColor = path.getFill() + '';
        path.setFill(this.hoverColors[cc]);
    } else if (this.hoverColor) {
        path.currentFillColor = path.getFill() + '';
        path.setFill(this.hoverColor);
    }
};

JQVMap.prototype.isSelected = function (cc) {
    return this.selectIndex(cc) >= 0;
};

JQVMap.prototype.makeDraggable = function () {
    var mouseDown = false;
    var oldPageX, oldPageY;
    var self = this;

    self.isMoving = false;
    self.isMovingTimeout = false;

    var lastTouchCount;
    var touchCenterX;
    var touchCenterY;
    var touchStartDistance;
    var touchStartScale;
    var touchX;
    var touchY;

    this.container.mousemove(function (e) {

        if (mouseDown) {
            self.transX -= (oldPageX - e.pageX) / self.scale;
            self.transY -= (oldPageY - e.pageY) / self.scale;

            self.applyTransform();

            oldPageX = e.pageX;
            oldPageY = e.pageY;

            self.isMoving = true;
            if (self.isMovingTimeout) {
                clearTimeout(self.isMovingTimeout);
            }

            self.container.trigger('drag');
        }

        return false;

    }).mousedown(function (e) {

        mouseDown = true;
        oldPageX = e.pageX;
        oldPageY = e.pageY;

        return false;

    }).mouseup(function () {

        mouseDown = false;

        clearTimeout(self.isMovingTimeout);
        self.isMovingTimeout = setTimeout(function () {
            self.isMoving = false;
        }, 100);

        return false;

    }).mouseout(function () {

        if (mouseDown && self.isMoving) {

            clearTimeout(self.isMovingTimeout);
            self.isMovingTimeout = setTimeout(function () {
                mouseDown = false;
                self.isMoving = false;
            }, 100);

            return false;
        }
    });

    jQuery(this.container).bind('touchmove', function (e) {

        var offset;
        var scale;
        var touches = e.originalEvent.touches;
        var transformXOld;
        var transformYOld;

        if (touches.length === 1) {
            if (lastTouchCount === 1) {

                if (touchX === touches[0].pageX && touchY === touches[0].pageY) {
                    return;
                }

                transformXOld = self.transX;
                transformYOld = self.transY;

                self.transX -= (touchX - touches[0].pageX) / self.scale;
                self.transY -= (touchY - touches[0].pageY) / self.scale;

                self.applyTransform();

                if (transformXOld !== self.transX || transformYOld !== self.transY) {
                    e.preventDefault();
                }

                self.isMoving = true;
                if (self.isMovingTimeout) {
                    clearTimeout(self.isMovingTimeout);
                }
            }

            touchX = touches[0].pageX;
            touchY = touches[0].pageY;

        } else if (touches.length === 2) {

            if (lastTouchCount === 2) {
                scale = Math.sqrt(
                    Math.pow(touches[0].pageX - touches[1].pageX, 2) +
                    Math.pow(touches[0].pageY - touches[1].pageY, 2)
                ) / touchStartDistance;

                self.setScale(
                    touchStartScale * scale,
                    touchCenterX,
                    touchCenterY
                );

                e.preventDefault();

            } else {

                offset = jQuery(self.container).offset();
                if (touches[0].pageX > touches[1].pageX) {
                    touchCenterX = touches[1].pageX + (touches[0].pageX - touches[1].pageX) / 2;
                } else {
                    touchCenterX = touches[0].pageX + (touches[1].pageX - touches[0].pageX) / 2;
                }

                if (touches[0].pageY > touches[1].pageY) {
                    touchCenterY = touches[1].pageY + (touches[0].pageY - touches[1].pageY) / 2;
                } else {
                    touchCenterY = touches[0].pageY + (touches[1].pageY - touches[0].pageY) / 2;
                }

                touchCenterX -= offset.left;
                touchCenterY -= offset.top;
                touchStartScale = self.scale;

                touchStartDistance = Math.sqrt(
                    Math.pow(touches[0].pageX - touches[1].pageX, 2) +
                    Math.pow(touches[0].pageY - touches[1].pageY, 2)
                );
            }
        }

        lastTouchCount = touches.length;
    });

    jQuery(this.container).bind('touchstart', function () {
        lastTouchCount = 0;
    });

    jQuery(this.container).bind('touchend', function () {
        lastTouchCount = 0;
    });
};

JQVMap.prototype.placePins = function (pins, pinMode) {
    var map = this;

    if (!pinMode || (pinMode !== 'content' && pinMode !== 'id')) {
        pinMode = 'content';
    }

    if (pinMode === 'content') {//treat pin as content
        jQuery.each(pins, function (index, pin) {
            if (jQuery('#' + map.getCountryId(index)).length === 0) {
                return;
            }

            var pinIndex = map.getPinId(index);
            var $pin = jQuery('#' + pinIndex);
            if ($pin.length > 0) {
                $pin.remove();
            }
            map.container.append('<div id="' + pinIndex + '" for="' + index + '" class="jqvmap-pin" style="position:absolute">' + pin + '</div>');
        });
    } else { //treat pin as id of an html content
        jQuery.each(pins, function (index, pin) {
            if (jQuery('#' + map.getCountryId(index)).length === 0) {
                return;
            }
            var pinIndex = map.getPinId(index);
            var $pin = jQuery('#' + pinIndex);
            if ($pin.length > 0) {
                $pin.remove();
            }
            map.container.append('<div id="' + pinIndex + '" for="' + index + '" class="jqvmap-pin" style="position:absolute"></div>');
            $pin.append(jQuery('#' + pin));
        });
    }

    this.positionPins();
    if (!this.pinHandlers) {
        this.pinHandlers = true;
        var positionFix = function () {
            map.positionPins();
        };
        this.container.bind('zoomIn', positionFix)
            .bind('zoomOut', positionFix)
            .bind('drag', positionFix);
    }
};

JQVMap.prototype.positionPins = function () {
    var map = this;
    var pins = this.container.find('.jqvmap-pin');
    jQuery.each(pins, function (index, pinObj) {
        pinObj = jQuery(pinObj);
        var countryId = map.getCountryId(pinObj.attr('for').toLowerCase());
        var countryObj = jQuery('#' + countryId);
        var bbox = countryObj[0].getBBox();

        var scale = map.scale;
        var rootCoords = map.canvas.rootGroup.getBoundingClientRect();
        var mapCoords = map.container[0].getBoundingClientRect();
        var coords = {
            left: rootCoords.left - mapCoords.left,
            top: rootCoords.top - mapCoords.top
        };

        var middleX = (bbox.x * scale) + ((bbox.width * scale) / 2);
        var middleY = (bbox.y * scale) + ((bbox.height * scale) / 2);

        pinObj.css({
            left: coords.left + middleX - (pinObj.width() / 2),
            top: coords.top + middleY - (pinObj.height() / 2)
        });
    });
};

JQVMap.prototype.removePin = function (cc) {
    cc = cc.toLowerCase();
    jQuery('#' + this.getPinId(cc)).remove();
};

JQVMap.prototype.removePins = function () {
    this.container.find('.jqvmap-pin').remove();
};

JQVMap.prototype.reset = function () {
    for (var key in this.countries) {
        this.countries[key].setFill(this.color);
    }
    this.scale = this.baseScale;
    this.transX = this.baseTransX;
    this.transY = this.baseTransY;
    this.applyTransform();
};

JQVMap.prototype.resize = function () {
    var curBaseScale = this.baseScale;
    if (this.width / this.height > this.defaultWidth / this.defaultHeight) {
        this.baseScale = this.height / this.defaultHeight;
        this.baseTransX = Math.abs(this.width - this.defaultWidth * this.baseScale) / (2 * this.baseScale);
    } else {
        this.baseScale = this.width / this.defaultWidth;
        this.baseTransY = Math.abs(this.height - this.defaultHeight * this.baseScale) / (2 * this.baseScale);
    }
    this.scale *= this.baseScale / curBaseScale;
    this.transX *= this.baseScale / curBaseScale;
    this.transY *= this.baseScale / curBaseScale;
};

JQVMap.prototype.select = function (cc, path) {
    cc = cc.toLowerCase();
    path = path || jQuery('#' + this.getCountryId(cc))[0];

    if (!this.isSelected(cc)) {
        if (this.multiSelectRegion) {
            this.selectedRegions.push(cc);
        } else {
            this.selectedRegions = [cc];
        }

        jQuery(this.container).trigger('regionSelect.jqvmap', [cc]);
        if (this.selectedColor && path) {
            path.currentFillColor = this.selectedColor;
            path.setFill(this.selectedColor);
        }
    }
};

JQVMap.prototype.selectIndex = function (cc) {
    cc = cc.toLowerCase();
    for (var i = 0; i < this.selectedRegions.length; i++) {
        if (cc === this.selectedRegions[i]) {
            return i;
        }
    }
    return -1;
};

JQVMap.prototype.setBackgroundColor = function (backgroundColor) {
    this.container.css('background-color', backgroundColor);
};

JQVMap.prototype.setColors = function (key, color) {
    if (typeof key === 'string') {
        this.countries[key].setFill(color);
        this.countries[key].setAttribute('original', color);
    } else {
        var colors = key;

        for (var code in colors) {
            if (this.countries[code]) {
                this.countries[code].setFill(colors[code]);
                this.countries[code].setAttribute('original', colors[code]);
            }
        }
    }
};

JQVMap.prototype.setNormalizeFunction = function (f) {
    this.colorScale.setNormalizeFunction(f);

    if (this.values) {
        this.setValues(this.values);
    }
};

JQVMap.prototype.setScale = function (scale) {
    this.scale = scale;
    this.applyTransform();
};

JQVMap.prototype.setScaleColors = function (colors) {
    this.colorScale.setColors(colors);

    if (this.values) {
        this.setValues(this.values);
    }
};

JQVMap.prototype.setValues = function (values) {
    var max = 0,
        min = Number.MAX_VALUE,
        val;

    for (var cc in values) {
        cc = cc.toLowerCase();
        val = parseFloat(values[cc]);

        if (isNaN(val)) {
            continue;
        }
        if (val > max) {
            max = values[cc];
        }
        if (val < min) {
            min = val;
        }
    }

    if (min === max) {
        max++;
    }

    this.colorScale.setMin(min);
    this.colorScale.setMax(max);

    var colors = {};
    for (cc in values) {
        cc = cc.toLowerCase();
        val = parseFloat(values[cc]);
        colors[cc] = isNaN(val) ? this.color : this.colorScale.getColor(val);
    }
    this.setColors(colors);
    this.values = values;
};

JQVMap.prototype.unhighlight = function (cc, path) {
    cc = cc.toLowerCase();
    path = path || jQuery('#' + this.getCountryId(cc))[0];
    path.setOpacity(1);
    if (path.currentFillColor) {
        path.setFill(path.currentFillColor);
    }
};

JQVMap.prototype.zoomIn = function () {
    var map = this;
    var sliderDelta = (jQuery('#zoom').innerHeight() - 6 * 2 - 15 * 2 - 3 * 2 - 7 - 6) / (this.zoomMaxStep - this.zoomCurStep);

    if (map.zoomCurStep < map.zoomMaxStep) {
        map.transX -= (map.width / map.scale - map.width / (map.scale * map.zoomStep)) / 2;
        map.transY -= (map.height / map.scale - map.height / (map.scale * map.zoomStep)) / 2;
        map.setScale(map.scale * map.zoomStep);
        map.zoomCurStep++;

        var $slider = jQuery('#zoomSlider');

        $slider.css('top', parseInt($slider.css('top'), 10) - sliderDelta);

        map.container.trigger('zoomIn');
    }
};

JQVMap.prototype.zoomOut = function () {
    var map = this;
    var sliderDelta = (jQuery('#zoom').innerHeight() - 6 * 2 - 15 * 2 - 3 * 2 - 7 - 6) / (this.zoomMaxStep - this.zoomCurStep);

    if (map.zoomCurStep > 1) {
        map.transX += (map.width / (map.scale / map.zoomStep) - map.width / map.scale) / 2;
        map.transY += (map.height / (map.scale / map.zoomStep) - map.height / map.scale) / 2;
        map.setScale(map.scale / map.zoomStep);
        map.zoomCurStep--;

        var $slider = jQuery('#zoomSlider');

        $slider.css('top', parseInt($slider.css('top'), 10) + sliderDelta);

        map.container.trigger('zoomOut');
    }
};

VectorCanvas.prototype.applyTransformParams = function (scale, transX, transY) {
    if (this.mode === 'svg') {
        this.rootGroup.setAttribute('transform', 'scale(' + scale + ') translate(' + transX + ', ' + transY + ')');
    } else {
        this.rootGroup.coordorigin = (this.width - transX) + ',' + (this.height - transY);
        this.rootGroup.coordsize = this.width / scale + ',' + this.height / scale;
    }
};

VectorCanvas.prototype.createGroup = function (isRoot) {
    var node;
    if (this.mode === 'svg') {
        node = this.createSvgNode('g');
    } else {
        node = this.createVmlNode('group');
        node.style.width = this.width + 'px';
        node.style.height = this.height + 'px';
        node.style.left = '0px';
        node.style.top = '0px';
        node.coordorigin = '0 0';
        node.coordsize = this.width + ' ' + this.height;
    }

    if (isRoot) {
        this.rootGroup = node;
    }
    return node;
};

VectorCanvas.prototype.createPath = function (config) {
    var node;
    if (this.mode === 'svg') {
        node = this.createSvgNode('path');
        node.setAttribute('d', config.path);

        if (this.params.borderColor !== null) {
            node.setAttribute('stroke', this.params.borderColor);
        }
        if (this.params.borderWidth > 0) {
            node.setAttribute('stroke-width', this.params.borderWidth);
            node.setAttribute('stroke-linecap', 'round');
            node.setAttribute('stroke-linejoin', 'round');
        }
        if (this.params.borderOpacity > 0) {
            node.setAttribute('stroke-opacity', this.params.borderOpacity);
        }

        node.setFill = function (color) {
            this.setAttribute('fill', color);
            if (this.getAttribute('original') === null) {
                this.setAttribute('original', color);
            }
        };

        node.getFill = function () {
            return this.getAttribute('fill');
        };

        node.getOriginalFill = function () {
            return this.getAttribute('original');
        };

        node.setOpacity = function (opacity) {
            this.setAttribute('fill-opacity', opacity);
        };
    } else {
        node = this.createVmlNode('shape');
        node.coordorigin = '0 0';
        node.coordsize = this.width + ' ' + this.height;
        node.style.width = this.width + 'px';
        node.style.height = this.height + 'px';
        node.fillcolor = JQVMap.defaultFillColor;
        node.stroked = false;
        node.path = VectorCanvas.pathSvgToVml(config.path);

        var scale = this.createVmlNode('skew');
        scale.on = true;
        scale.matrix = '0.01,0,0,0.01,0,0';
        scale.offset = '0,0';

        node.appendChild(scale);

        var fill = this.createVmlNode('fill');
        node.appendChild(fill);

        node.setFill = function (color) {
            this.getElementsByTagName('fill')[0].color = color;
            if (this.getAttribute('original') === null) {
                this.setAttribute('original', color);
            }
        };

        node.getFill = function () {
            return this.getElementsByTagName('fill')[0].color;
        };
        node.getOriginalFill = function () {
            return this.getAttribute('original');
        };
        node.setOpacity = function (opacity) {
            this.getElementsByTagName('fill')[0].opacity = parseInt(opacity * 100, 10) + '%';
        };
    }
    return node;
};

VectorCanvas.prototype.pathSvgToVml = function (path) {
    var result = '';
    var cx = 0, cy = 0, ctrlx, ctrly;

    return path.replace(/([MmLlHhVvCcSs])((?:-?(?:\d+)?(?:\.\d+)?,?\s?)+)/g, function (segment, letter, coords) {
        coords = coords.replace(/(\d)-/g, '$1,-').replace(/\s+/g, ',').split(',');
        if (!coords[0]) {
            coords.shift();
        }

        for (var i = 0, l = coords.length; i < l; i++) {
            coords[i] = Math.round(100 * coords[i]);
        }

        switch (letter) {
            case 'm':
                cx += coords[0];
                cy += coords[1];
                result = 't' + coords.join(',');
                break;

            case 'M':
                cx = coords[0];
                cy = coords[1];
                result = 'm' + coords.join(',');
                break;

            case 'l':
                cx += coords[0];
                cy += coords[1];
                result = 'r' + coords.join(',');
                break;

            case 'L':
                cx = coords[0];
                cy = coords[1];
                result = 'l' + coords.join(',');
                break;

            case 'h':
                cx += coords[0];
                result = 'r' + coords[0] + ',0';
                break;

            case 'H':
                cx = coords[0];
                result = 'l' + cx + ',' + cy;
                break;

            case 'v':
                cy += coords[0];
                result = 'r0,' + coords[0];
                break;

            case 'V':
                cy = coords[0];
                result = 'l' + cx + ',' + cy;
                break;

            case 'c':
                ctrlx = cx + coords[coords.length - 4];
                ctrly = cy + coords[coords.length - 3];
                cx += coords[coords.length - 2];
                cy += coords[coords.length - 1];
                result = 'v' + coords.join(',');
                break;

            case 'C':
                ctrlx = coords[coords.length - 4];
                ctrly = coords[coords.length - 3];
                cx = coords[coords.length - 2];
                cy = coords[coords.length - 1];
                result = 'c' + coords.join(',');
                break;

            case 's':
                coords.unshift(cy - ctrly);
                coords.unshift(cx - ctrlx);
                ctrlx = cx + coords[coords.length - 4];
                ctrly = cy + coords[coords.length - 3];
                cx += coords[coords.length - 2];
                cy += coords[coords.length - 1];
                result = 'v' + coords.join(',');
                break;

            case 'S':
                coords.unshift(cy + cy - ctrly);
                coords.unshift(cx + cx - ctrlx);
                ctrlx = coords[coords.length - 4];
                ctrly = coords[coords.length - 3];
                cx = coords[coords.length - 2];
                cy = coords[coords.length - 1];
                result = 'c' + coords.join(',');
                break;

            default:
                break;
        }

        return result;

    }).replace(/z/g, '');
};

VectorCanvas.prototype.setSize = function (width, height) {
    if (this.mode === 'svg') {
        this.canvas.setAttribute('width', width);
        this.canvas.setAttribute('height', height);
    } else {
        this.canvas.style.width = width + 'px';
        this.canvas.style.height = height + 'px';
        this.canvas.coordsize = width + ' ' + height;
        this.canvas.coordorigin = '0 0';
        if (this.rootGroup) {
            var paths = this.rootGroup.getElementsByTagName('shape');
            for (var i = 0, l = paths.length; i < l; i++) {
                paths[i].coordsize = width + ' ' + height;
                paths[i].style.width = width + 'px';
                paths[i].style.height = height + 'px';
            }
            this.rootGroup.coordsize = width + ' ' + height;
            this.rootGroup.style.width = width + 'px';
            this.rootGroup.style.height = height + 'px';
        }
    }
    this.width = width;
    this.height = height;
};
